home *** CD-ROM | disk | FTP | other *** search
/ Programming Windows 95 / Programming Windows 95.iso / code / CHAP20 / CALLER.C next >
Encoding:
C/C++ Source or Header  |  1996-01-01  |  13.9 KB  |  359 lines
  1. /*---------------------------------------------
  2.    CALLER.C -- Call into private OLE component
  3.                (c) Paul Yao, 1996
  4.   ---------------------------------------------*/
  5. #include <windows.h>
  6. #include "caller.h"
  7. #include "imalloc.h"
  8.  
  9. LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
  10.  
  11. char szWndClass[] = "CallerWindow" ;
  12. char szAppName[]  = "Malloc Caller" ;
  13.  
  14. //-------------------------------------------------------------------
  15. int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, 
  16.                     PSTR lpszCmdLine, int cmdShow)       
  17.      {
  18.      HWND        hwnd ;
  19.      MSG         msg ;
  20.      WNDCLASSEX  wc ;
  21.  
  22.      wc.cbSize        = sizeof (wc) ;
  23.      wc.lpszClassName = szWndClass ;
  24.      wc.hInstance     = hInstance ;
  25.      wc.lpfnWndProc   = WndProc ;
  26.      wc.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
  27.      wc.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
  28.      wc.lpszMenuName  = "MAIN" ;
  29.      wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1) ;
  30.      wc.style         = 0 ;
  31.      wc.cbClsExtra    = 0 ;
  32.      wc.cbWndExtra    = 0 ;
  33.      wc.hIconSm       = LoadIcon (NULL, IDI_APPLICATION) ;
  34.  
  35.      RegisterClassEx (&wc) ;
  36.  
  37.      hwnd = CreateWindowEx (0L, szWndClass, szAppName,
  38.                             WS_OVERLAPPEDWINDOW,  
  39.                             CW_USEDEFAULT, CW_USEDEFAULT,
  40.                             CW_USEDEFAULT, CW_USEDEFAULT,
  41.                             NULL, NULL, hInstance, NULL) ;
  42.  
  43.      ShowWindow (hwnd, cmdShow) ;
  44.      UpdateWindow (hwnd) ;
  45.  
  46.      while (GetMessage (&msg, NULL, 0, 0))
  47.           {
  48.           TranslateMessage (&msg) ; 
  49.           DispatchMessage (&msg) ;  
  50.           }
  51.      return msg.wParam ;
  52.      }
  53.  
  54. //-------------------------------------------------------------------
  55. LRESULT CALLBACK 
  56. WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) 
  57.      {
  58.      static int       iCurLine = 0 ;
  59.      static LPMALLOC  pMalloc = NULL ;
  60.      static LPSTR     szLine[10] ;
  61.      static RECT      rHit[10] ;
  62.  
  63.      switch (iMsg)
  64.           {
  65.           case WM_CREATE :
  66.                // Initialize data pointer array
  67.                ZeroMemory (szLine, sizeof (szLine)) ;
  68.                return 0 ;
  69.  
  70.           case WM_COMMAND :
  71.                switch (LOWORD (wParam))
  72.                     {
  73.                     case IDM_CREATE :
  74.                          pMalloc = CreateAllocator () ;
  75.                          if (pMalloc == NULL)
  76.                               {
  77.                               MessageBox (hwnd, "Error: No allocator", 
  78.                                           szAppName, MB_OK) ;
  79.                               return 0 ;
  80.                               }
  81.  
  82.                          InvalidateRect (hwnd, NULL, TRUE) ;
  83.                          return 0 ;
  84.  
  85.                     case IDM_DESTROY :
  86.                          {
  87.                          int i ;
  88.  
  89.                          // Mark allocated blocks as invalid
  90.                          for (i = 0 ; i < 10 ; i++)
  91.                               {
  92.                               if ((szLine[i] != NULL) &&
  93.                                   (pMalloc->lpVtbl->DidAlloc (pMalloc, 
  94.                                                               szLine[i])))
  95.                                    {
  96.                                    szLine[i] = NULL ;
  97.                                    }
  98.                               }
  99.  
  100.                          // Disconnect from & free allocator
  101.                          pMalloc->lpVtbl->Release (pMalloc) ;
  102.                          pMalloc = NULL ;
  103.  
  104.                          InvalidateRect (hwnd, NULL, TRUE) ;
  105.                          return 0 ;
  106.                          }
  107.  
  108.                     case IDM_IUNKNOWN :
  109.                          {
  110.                          LPUNKNOWN pUnk ;
  111.                          HRESULT hr =
  112.                               pMalloc->lpVtbl->QueryInterface (pMalloc, 
  113.                                                                IID_IUnknown,
  114.                                                                (void **) &pUnk) ;
  115.                          if (SUCCEEDED (hr))
  116.                               {
  117.                               pUnk->lpVtbl->Release (pUnk) ;
  118.                               MessageBox (hwnd, "IUnknown supported", 
  119.                                           szAppName, MB_OK) ;
  120.                               }
  121.                          else
  122.                               {
  123.                               MessageBox (hwnd, "IUnknown not supported", 
  124.                                           szAppName, MB_OK) ;
  125.                               }
  126.                          return 0 ;
  127.                          }
  128.  
  129.                     case IDM_IMALLOC :
  130.                          {
  131.                          LPUNKNOWN pUnk ;
  132.                          HRESULT hr =
  133.                               pMalloc->lpVtbl->QueryInterface (pMalloc, 
  134.                                                                IID_IMalloc,
  135.                                                                (void **) &pUnk) ;
  136.                          if (SUCCEEDED (hr))
  137.                               {
  138.                               pUnk->lpVtbl->Release (pUnk) ;
  139.                               MessageBox (hwnd, "IMalloc supported", 
  140.                                           szAppName, MB_OK) ;
  141.                               }
  142.                          else
  143.                               {
  144.                               MessageBox (hwnd, "IMalloc not supported", 
  145.                                           szAppName, MB_OK) ;
  146.                               }
  147.                          return 0 ;
  148.                          }
  149.  
  150.                     case IDM_IMARSHAL :
  151.                          {
  152.                          LPUNKNOWN pUnk ;
  153.                          HRESULT hr =
  154.                               pMalloc->lpVtbl->QueryInterface (pMalloc, 
  155.                                                                IID_IMarshal,
  156.                                                                (void **) &pUnk) ;
  157.                          if (SUCCEEDED (hr))
  158.                               {
  159.                               pUnk->lpVtbl->Release (pUnk) ;
  160.                               MessageBox (hwnd, "IMarshal supported",
  161.                                           szAppName, MB_OK) ;
  162.                               }
  163.                          else
  164.                               {
  165.                               MessageBox (hwnd, "IMarshal not supported",
  166.                                           szAppName, MB_OK) ;
  167.                               }
  168.                          return 0 ;
  169.                          }
  170.  
  171.                     case IDM_ALLOCATE_CUSTOM :
  172.                          if (szLine[iCurLine] != NULL)
  173.                               {
  174.                               MessageBox (hwnd, "Error: Free First", 
  175.                                           szAppName, MB_OK) ;
  176.                               return 0 ;
  177.                               }
  178.  
  179.                          // Allocate from IAllocate interface
  180.                          szLine[iCurLine] = 
  181.                               (char *) pMalloc->lpVtbl->Alloc (pMalloc, 100) ;
  182.                          lstrcpy (szLine[iCurLine], "*IMalloc memory*") ;
  183.  
  184.                          InvalidateRect (hwnd, NULL, TRUE) ;
  185.                          return 0 ;
  186.  
  187.                     case IDM_ALLOCATE_DEFAULT :
  188.                          if (szLine[iCurLine] != NULL)
  189.                               {
  190.                               MessageBox (hwnd, "Error: Free First", 
  191.                                           szAppName, MB_OK) ;
  192.                               return 0 ;
  193.                               }
  194.  
  195.                          // Allocate from default heap
  196.                          szLine[iCurLine] = (char *) malloc (100) ;
  197.                          lstrcpy (szLine[iCurLine], "-Malloc memory-") ;
  198.  
  199.                          InvalidateRect (hwnd, NULL, TRUE) ;
  200.                          return 0 ;
  201.  
  202.                     case IDM_FREE :
  203.                          if (szLine[iCurLine] == NULL)
  204.                               {
  205.                               MessageBox (hwnd, "Error: Nothing to free", 
  206.                                           szAppName, MB_OK) ;
  207.                               return 0 ;
  208.                               }
  209.  
  210.                          if (pMalloc == NULL)
  211.                               {
  212.                               goto FreeMalloc ;
  213.                               }
  214.  
  215.                          // Free allocated object
  216.                          if (pMalloc->lpVtbl->DidAlloc (pMalloc, 
  217.                                                         szLine[iCurLine]))
  218.                               {
  219.                               pMalloc->lpVtbl->Free (pMalloc, 
  220.                                                      szLine[iCurLine]) ;
  221.                               }
  222.                          else
  223.                               {
  224.                FreeMalloc:
  225.                               free (szLine[iCurLine]) ;
  226.                               }
  227.  
  228.                          szLine[iCurLine] = NULL ;
  229.  
  230.                          InvalidateRect (hwnd, NULL, TRUE) ;
  231.                          return 0 ;
  232.                          }
  233.  
  234.           case WM_DESTROY :
  235.                // Disconnect from & free allocator
  236.                if (pMalloc)
  237.                     {
  238.                     pMalloc->lpVtbl->Release (pMalloc) ;
  239.                     pMalloc = NULL ;
  240.                     }
  241.  
  242.                PostQuitMessage (0) ;  // Handle application shutdown
  243.                return 0 ;
  244.  
  245.           case WM_INITMENU :
  246.                {
  247.                HMENU hMenu = (HMENU) wParam ;
  248.                if (pMalloc)
  249.                     {
  250.                     EnableMenuItem (hMenu, IDM_CREATE,          MF_GRAYED) ;
  251.                     EnableMenuItem (hMenu, IDM_DESTROY,         MF_ENABLED) ;
  252.                     EnableMenuItem (hMenu, IDM_ALLOCATE_CUSTOM, MF_ENABLED) ;
  253.                     EnableMenuItem (hMenu, IDM_IUNKNOWN,        MF_ENABLED) ;
  254.                     EnableMenuItem (hMenu, IDM_IMALLOC,         MF_ENABLED) ;
  255.                     EnableMenuItem (hMenu, IDM_IMARSHAL,        MF_ENABLED) ;
  256.                     }
  257.                else
  258.                     {
  259.                     EnableMenuItem (hMenu, IDM_CREATE,          MF_ENABLED) ;
  260.                     EnableMenuItem (hMenu, IDM_DESTROY,         MF_GRAYED) ;
  261.                     EnableMenuItem (hMenu, IDM_ALLOCATE_CUSTOM, MF_GRAYED) ;
  262.                     EnableMenuItem (hMenu, IDM_IUNKNOWN,        MF_GRAYED) ;
  263.                     EnableMenuItem (hMenu, IDM_IMALLOC,         MF_GRAYED) ;
  264.                     EnableMenuItem (hMenu, IDM_IMARSHAL,        MF_GRAYED) ;
  265.                     }
  266.                return 0 ;
  267.                }
  268.  
  269.           case WM_LBUTTONDOWN :
  270.                {
  271.                int i ;
  272.                int x = LOWORD (lParam) ;
  273.                int y = HIWORD (lParam) ;
  274.                POINT pt = { x, y } ;
  275.  
  276.                for (i = 0 ; i < 10 ; i++)
  277.                     {
  278.                     if (PtInRect (&rHit[i], pt))
  279.                          {
  280.                          if (iCurLine != i)  // Minimize screen blink
  281.                               {
  282.                               InvalidateRect (hwnd, &rHit[iCurLine], TRUE) ;
  283.                               InvalidateRect (hwnd, &rHit[i], TRUE) ;
  284.                               iCurLine = i ;
  285.                               }
  286.                          break ;
  287.                          }    
  288.                     }
  289.                     return 0 ;
  290.                }
  291.  
  292.           case WM_PAINT :
  293.                {
  294.                char         szBuff[10] ;
  295.                COLORREF     crText, crBack ;
  296.                HDC          hdc ;
  297.                int          cc ;
  298.                int          i ;
  299.                int          XCount, XText, Y ;
  300.                int          cyLineHeight ;
  301.                PAINTSTRUCT  ps ;
  302.                RECT         rOpaque ;
  303.                TEXTMETRIC   tm ;
  304.  
  305.                hdc = BeginPaint (hwnd, &ps) ;
  306.  
  307.                // Fetch line height
  308.                GetTextMetrics (ps.hdc, &tm) ;
  309.                cyLineHeight = tm.tmHeight + tm.tmExternalLeading ;
  310.  
  311.                // Fetch current text colors
  312.                crText = GetTextColor (ps.hdc) ;
  313.                crBack = GetBkColor (ps.hdc) ;
  314.  
  315.                XCount = tm.tmAveCharWidth * 3 ;
  316.                XText  = XCount + tm.tmAveCharWidth * 7 ;
  317.                Y      = tm.tmHeight ;
  318.  
  319.                for (i = 0 ; i < 10 ; i++, Y += cyLineHeight)
  320.                     {
  321.                     // Set colors to highlight current line
  322.                     if (i == iCurLine)
  323.                          {
  324.                          SetTextColor (ps.hdc, crBack) ;
  325.                          SetBkColor (ps.hdc, crText) ;
  326.  
  327.                          SetRect (&rOpaque, 0, Y, 9999, Y + cyLineHeight) ;
  328.                          ExtTextOut (ps.hdc, 0, 0, ETO_OPAQUE, &rOpaque,
  329.                                      NULL, 0, NULL ) ;
  330.                          }
  331.                     else
  332.                          {
  333.                          SetTextColor (ps.hdc, crText) ;
  334.                          SetBkColor (ps.hdc, crBack) ;
  335.                          }
  336.  
  337.                     // Display line count
  338.                     cc = wsprintf (szBuff, "Line %d", i) ;
  339.                     TextOut (ps.hdc, XCount, Y, szBuff, cc) ;
  340.  
  341.                     // Display text if a string has been defined
  342.                     if (szLine[i] != NULL)
  343.                          {
  344.                          cc = lstrlen (szLine[i]) ;
  345.                          TextOut (ps.hdc, XText, Y, szLine[i], cc) ;
  346.                          }
  347.  
  348.                     // Calculate hit test rectangle
  349.                     SetRect (&rHit[i], 0, Y, 9999, Y + cyLineHeight) ;
  350.                     }
  351.  
  352.                EndPaint (hwnd, &ps) ;
  353.                return 0 ;
  354.                }
  355.           default :
  356.                return DefWindowProc (hwnd, iMsg, wParam, lParam) ;
  357.           }
  358.      }
  359.